import com.sun.org.apache.xalan.internal.res.XSLTErrorResources_zh_TW;

import javax.swing.plaf.SpinnerUI;
import java.util.Arrays;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Jared
 * Date: 2022-12-07
 * Time: 2:06
 */
public class Main {
    /**
     * 汉诺塔问题
     * @param pos1
     * @param pos2
     */
    public static void move(char pos1,char pos2){
        System.out.print(pos1+"->"+pos2+" ");
    }

    /**
     *
     * @param n     代表你的盘子的个数
     * @param pos1  盘子所在的起始位置
     * @param pos2  盘子的中转位置
     * @param pos3  盘子的结束位置
     */
    public static void hanio(int n,char pos1,char pos2,char pos3){
        if(n==1){
            move(pos1,pos3);
        }else{
            hanio(n-1,pos1,pos3,pos2);
            move(pos1,pos3);
            hanio(n-1,pos2,pos1,pos3);
        }
    }

    public static void main1(String[] args) {
        hanio(1,'A','B','C');
        System.out.println();
        hanio(2,'A','B','C');
        System.out.println();
        hanio(3,'A','B','C');
        System.out.println();
    }
    /*                      数组                          */
    //  存储一组相同数据类型的数据的集合
    public static void main2(String[] args) {
        int[] array ={1,2,3,4,5,6,7}; //虽然没写对象，但是实际上也是一个对象
        /*
            定义数组的时候，不能写具体的数字。int[10] arr 错误，编译器会自动推导
            可以用关键字new实例化一个数组对象，也意味着Java中的数组也是一个对象
        */
        int [] array2 = new int[3]; //数组中的存放三个默认为3的int值

        int [] array3 = new int[]{1,2,3,4,5};
        //[]内不能写数字，{}内部相当于对数组进行了初始化

        // 其实int arr []也是对的，但是更推荐int[]这种写法， 因为int和[]是一个整体
    }

    public static void main3(String[] args) {
        int[] array ={1,2,3,4,5,6,7};
        System.out.println(array.length);
        System.out.println(array[3]);
        array[3]=10;
        System.out.println(array[3]);
    }

    /**
     * 遍历数组
     * @param args
     */
    public static void main4(String[] args) {
        int[] array ={1,2,3,4,5,6,7};
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }
        System.out.println();

        for(int x:array){
            System.out.print(x+" ");
        }
        System.out.println();

        // 借助Java的操作数组的工具类 Arrays.toString :将参数的数组，以字符串的形式进行输出
        String  ret = Arrays.toString(array);
        System.out.println(ret);
    }

    /**
     * 检查数组的有序性
     */
    public static boolean isUp(int[] array){
        for (int i = 0; i < array.length-1; i++) {
            if(array[i] > array[i+1]){
                return false;
            }
        }
        return true;
    }

    /**
     * 对数组进行冒泡排序
     * @param array 表示传过来的数组
     */
    public static void bubbleSort(int[] array){
        // i表示趟数
        for (int i = 0; i < array.length - 1; i++) {
            boolean flg =false;
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j] > array[j+1]){
                    int tmp =array[j];
                    array[j]=array[j+1];
                    array[j+1]=tmp;
                    flg=true;
                }
            }
            if(flg==false){
               return;
            }
        }
    }


    /**
     * fill 是操作数组的Arrays类的填充方法
     * @param args
     */
    public static void main6(String[] args) {
        int [] array=new int[10];
        Arrays.fill(array,2,6,199); //[2,6)
        System.out.println(Arrays.toString(array));
    }

    public static void main5(String[] args) {
        int[] arr = {1,2,3,10,5,6};
        //System.out.println(isUp(arr));
        //bubbleSort(arr);
        //System.out.println(Arrays.toString(arr));
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 数组逆置
     * @param array
     */
    public static void reverse(int[] array){
        int i=0;
        int j=array.length-1;
        while (i<j){
            int tmp = array[i];
            array[i]=array[j];
            array[j]=tmp;
            i++;
            j--;
        }
    }

    /**
     * 将数组中的偶数放到奇数的前面
     * @param array
     */
    public static void func(int[] array){
        int i=0;
        int j=array.length-1;
        while (i<j){
            while (i<j && array[i]%2==0) {
                i++;
            }//此时i下标一定是奇数
            while (i<j && array[j]%2!=0){
                j--;
            }//此时j下标一定是偶数
            int tmp=array[i];
            array[i]=array[j];
            array[j]=tmp;
        }
    }

    /**
     * 数组的拷贝1
     * @param array
     * @return
     */
    public static int[] copyArray(int[] array){
        int[] copy =new int[array.length];
        for (int i = 0; i < array.length; i++) {
            copy[i]=array[i];
        }
        return copy;
    }

    public static void  my2string(int[] arr){
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(String.valueOf(arr[i]));
            if(i<arr.length-1){
                System.out.print(",");
            }
        }
        System.out.println("]");
    }

    public static void main7(String[] args) {
        int[] arr = {1,2,3,10,5,6};
        /*int[] ret =copyArray(arr);
        System.out.println(Arrays.toString(ret));*/

        /**
         * 数组的拷贝2
         */
        int[] ret = Arrays.copyOf(arr,arr.length);
        System.out.println(Arrays.toString(ret));

        /**
         * 数组的拷贝3
         */
        int[] copy=new int[arr.length];
        System.arraycopy(arr,0,copy,0,arr.length);
        System.out.println(Arrays.toString(copy));

        /**
         *  数组的拷贝4
         */
        int[] copy4=arr.clone();
        System.out.println(Arrays.toString(copy4));
    }

    /**
     * 求数组的平均数
     * @param arr
     * @return
     */
    public static double avg(int[] arr){
        double avg = 0;
        int sum =0;
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        avg = (double) sum/arr.length;
        return avg;
    }

    /**
     * 求数组的中所有元素之和
     * @param arr
     * @return
     */
    public static int sum(int[] arr){
        int sum = 0 ;
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        return sum;
    }

    public static void transform(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            arr[i]*=2;
        }
    }

    public static void print(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

    public static int binerFind(int[] arr,int key){
        int left=0;
        int right=arr.length-1;
        int mid=0;
        while (left<=right){
            mid=(left+right)/2;
            if(arr[mid]>key){
                right=mid-1;
            }
            else if(arr[mid]<key){
                left=mid+1;
            }
            else {
               return mid;
            }
        }
        return  -1;
    }

    /**
     * 在同一个类中定义多个方法：要求不仅可以求2个整数的最大值，还可以求3个小数的最大值
     * @param args
     */
    public static int sum(int a,int b){
        return a>b?a:b;
    }

    public static double sum(double a,double b,double c){
        double tmp = a>b?a:b;
        return tmp>c?tmp:c;
    }

    /**
     *
     作业标题(1691)
     求和的重载
     作业内容
     在同一个类中,分别定义求两个整数的方法 和 三个小数之和的方法。 并执行代码，求出结果
     * @param args
     */

    public static void main(String[] args) {
        System.out.println(sum(1,2));
        System.out.println(sum(1.0,2.1,3.2));
    }
}
